/**
 * Markdown智能排版 Word Add-in
 * 主要功能：解析Markdown内容和自定义排版规则，格式化并插入到Word文档
 */

// 全局变量
let isInitialized = false;

// Office.js 初始化
Office.onReady((info) => {
    if (info.host === Office.HostType.Word) {
        document.getElementById("sideload-msg").style.display = "none";
        document.getElementById("app-body").style.display = "flex";
        isInitialized = true;
        
        // 绑定事件处理器
        document.getElementById("processButton").onclick = processMarkdownContent;
        
        // 设置默认样式规则
        setDefaultStyleRules();
        
        showStatus("加载项已准备就绪", "success");
    }
});

/**
 * 设置默认的排版规则
 */
function setDefaultStyleRules() {
    const defaultRules = `[默认设置]
字体名称: Calibri
字体大小: 11pt
行距: 1.5
段前间距: 0pt
段后间距: 6pt

[标题一]
基于: 默认设置
字体名称: 宋体
字体大小: 小一号
加粗: 是
对齐方式: 居中
段前间距: 1行
段后间距: 12pt

[标题二]
基于: 默认设置
字体名称: 黑体
字体大小: 三号
加粗: 是
段前间距: 18pt
段后间距: 6pt

[标题三]
基于: 默认设置
字体名称: 黑体
字体大小: 四号
加粗: 是
段前间距: 12pt
段后间距: 6pt

[正文]
基于: 默认设置
字体名称: 宋体
字体大小: 小四号
首行缩进: 2字符
对齐方式: 两端对齐
行距: 1.25倍`;

    document.getElementById("styleRulesInput").value = defaultRules;
}

/**
 * 主处理函数：解析Markdown和样式规则，然后插入到Word文档
 */
async function processMarkdownContent() {
    if (!isInitialized) {
        showStatus("加载项尚未初始化完成", "warning");
        return;
    }

    const markdownText = document.getElementById("markdownInput").value.trim();
    const styleRulesText = document.getElementById("styleRulesInput").value.trim();

    if (!markdownText) {
        showStatus("请输入Markdown内容", "warning");
        return;
    }

    if (!styleRulesText) {
        showStatus("请输入排版规则", "warning");
        return;
    }

    try {
        // 显示处理中状态
        showStatus("正在处理内容...", "info");
        setLoadingState(true);

        // 解析样式规则
        const styleRules = parseStyleRules(styleRulesText);
        
        // 解析Markdown内容
        const markdownElements = parseMarkdown(markdownText);

        // 插入到Word文档
        await insertToWord(markdownElements, styleRules);

        showStatus("内容已成功插入到文档", "success");
    } catch (error) {
        console.error("处理过程中发生错误:", error);
        showStatus(`处理失败: ${error.message}`, "error");
    } finally {
        setLoadingState(false);
    }
}

/**
 * 解析样式规则
 * @param {string} rulesText - 样式规则文本
 * @returns {Object} 解析后的样式规则对象
 */
function parseStyleRules(rulesText) {
    const rules = {};
    const sections = rulesText.split(/\[([^\]]+)\]/);
    
    for (let i = 1; i < sections.length; i += 2) {
        const sectionName = sections[i].trim();
        const sectionContent = sections[i + 1];
        
        if (sectionContent) {
            rules[sectionName] = parseSectionProperties(sectionContent);
        }
    }

    // 处理继承关系
    for (const [sectionName, sectionRule] of Object.entries(rules)) {
        if (sectionRule['基于']) {
            const baseName = sectionRule['基于'];
            if (rules[baseName]) {
                rules[sectionName] = { ...rules[baseName], ...sectionRule };
            }
        }
    }

    return rules;
}

/**
 * 解析节属性
 * @param {string} content - 节内容
 * @returns {Object} 属性对象
 */
function parseSectionProperties(content) {
    const properties = {};
    const lines = content.split('\n');
    
    for (const line of lines) {
        const trimmedLine = line.trim();
        if (trimmedLine && !trimmedLine.startsWith('#')) {
            const colonIndex = trimmedLine.indexOf(':');
            if (colonIndex > 0) {
                const key = trimmedLine.substring(0, colonIndex).trim();
                const value = trimmedLine.substring(colonIndex + 1).trim();
                properties[key] = value;
            }
        }
    }
    
    return properties;
}

/**
 * 简单的Markdown解析器
 * @param {string} markdown - Markdown文本
 * @returns {Array} 解析后的元素数组
 */
function parseMarkdown(markdown) {
    const lines = markdown.split('\n');
    const elements = [];
    
    for (let i = 0; i < lines.length; i++) {
        const line = lines[i];
        const trimmedLine = line.trim();
        
        if (!trimmedLine) continue;
        
        // 解析标题
        if (trimmedLine.startsWith('#')) {
            const level = (trimmedLine.match(/^#+/) || [''])[0].length;
            const text = trimmedLine.replace(/^#+\s*/, '');
            
            let type;
            switch (level) {
                case 1: type = '标题一'; break;
                case 2: type = '标题二'; break;
                case 3: type = '标题三'; break;
                default: type = '标题三'; break;
            }
            
            elements.push({
                type: type,
                text: text,
                formatting: parseInlineFormatting(text)
            });
        } else {
            // 普通段落
            elements.push({
                type: '正文',
                text: trimmedLine,
                formatting: parseInlineFormatting(trimmedLine)
            });
        }
    }
    
    return elements;
}

/**
 * 解析行内格式（加粗、斜体）
 * @param {string} text - 文本
 * @returns {Array} 格式化片段数组
 */
function parseInlineFormatting(text) {
    const segments = [];
    let currentText = text;
    let position = 0;
    
    // 简单的正则表达式匹配加粗和斜体
    const boldRegex = /\*\*([^*]+)\*\*/g;
    const italicRegex = /\*([^*]+)\*/g;
    
    // 先处理加粗
    let lastIndex = 0;
    let match;
    
    while ((match = boldRegex.exec(text)) !== null) {
        // 添加前面的普通文本
        if (match.index > lastIndex) {
            const beforeText = text.substring(lastIndex, match.index);
            if (beforeText) {
                segments.push({ text: beforeText, bold: false, italic: false });
            }
        }
        
        // 添加加粗文本
        segments.push({ text: match[1], bold: true, italic: false });
        lastIndex = match.index + match[0].length;
    }
    
    // 添加剩余的普通文本
    if (lastIndex < text.length) {
        const remainingText = text.substring(lastIndex);
        if (remainingText) {
            segments.push({ text: remainingText, bold: false, italic: false });
        }
    }
    
    // 如果没有找到加粗文本，处理斜体
    if (segments.length === 0) {
        lastIndex = 0;
        while ((match = italicRegex.exec(text)) !== null) {
            // 添加前面的普通文本
            if (match.index > lastIndex) {
                const beforeText = text.substring(lastIndex, match.index);
                if (beforeText) {
                    segments.push({ text: beforeText, bold: false, italic: false });
                }
            }
            
            // 添加斜体文本
            segments.push({ text: match[1], bold: false, italic: true });
            lastIndex = match.index + match[0].length;
        }
        
        // 添加剩余的普通文本
        if (lastIndex < text.length) {
            const remainingText = text.substring(lastIndex);
            if (remainingText) {
                segments.push({ text: remainingText, bold: false, italic: false });
            }
        }
    }
    
    // 如果没有任何格式，返回原始文本
    if (segments.length === 0) {
        segments.push({ text: text, bold: false, italic: false });
    }
    
    return segments;
}

/**
 * 将内容插入到Word文档
 * @param {Array} elements - Markdown元素数组
 * @param {Object} styleRules - 样式规则对象
 */
async function insertToWord(elements, styleRules) {
    return Word.run(async (context) => {
        const selection = context.document.getSelection();
        
        for (const element of elements) {
            const rule = styleRules[element.type] || styleRules['正文'] || {};
            
            // 创建段落
            const paragraph = selection.insertParagraph("", Word.InsertLocation.end);
            
            // 处理带格式的文本
            if (element.formatting && element.formatting.length > 0) {
                for (const segment of element.formatting) {
                    const range = paragraph.insertText(segment.text, Word.InsertLocation.end);
                    
                    // 应用内联格式
                    if (segment.bold || rule['加粗'] === '是') {
                        range.font.bold = true;
                    }
                    if (segment.italic) {
                        range.font.italic = true;
                    }
                }
            } else {
                paragraph.insertText(element.text, Word.InsertLocation.end);
            }
            
            // 应用样式规则
            applyStyleToElement(paragraph, rule);
        }
        
        await context.sync();
    });
}

/**
 * 将样式规则应用到Word元素
 * @param {Object} element - Word段落对象
 * @param {Object} rule - 样式规则
 */
function applyStyleToElement(element, rule) {
    // 字体设置
    if (rule['字体名称']) {
        element.font.name = rule['字体名称'];
    }
    
    if (rule['字体大小']) {
        element.font.size = convertFontSize(rule['字体大小']);
    }
    
    if (rule['加粗'] === '是') {
        element.font.bold = true;
    }
    
    if (rule['斜体'] === '是') {
        element.font.italic = true;
    }
    
    // 段落格式
    if (rule['对齐方式']) {
        element.alignment = convertAlignment(rule['对齐方式']);
    }
    
    if (rule['首行缩进']) {
        element.firstLineIndent = convertIndent(rule['首行缩进'], rule['字体大小'] || '12pt');
    }
    
    if (rule['行距']) {
        element.lineSpacing = convertLineSpacing(rule['行距']);
    }
    
    if (rule['段前间距']) {
        element.spaceBefore = convertSpacing(rule['段前间距'], rule['字体大小'] || '12pt');
    }
    
    if (rule['段后间距']) {
        element.spaceAfter = convertSpacing(rule['段后间距'], rule['字体大小'] || '12pt');
    }
}

/**
 * 转换字体大小
 * @param {string} size - 字体大小字符串
 * @returns {number} 磅值
 */
function convertFontSize(size) {
    // 中文号数映射表
    const chineseSizeMap = {
        '初号': 42,
        '小初号': 36,
        '一号': 26,
        '小一号': 24,
        '二号': 22,
        '小二号': 18,
        '三号': 16,
        '小三号': 15,
        '四号': 14,
        '小四号': 12,
        '五号': 10.5,
        '小五号': 9,
        '六号': 7.5,
        '小六号': 6.5,
        '七号': 5.5,
        '八号': 5
    };
    
    if (chineseSizeMap[size]) {
        return chineseSizeMap[size];
    }
    
    // 提取数字和单位
    const match = size.match(/^(\d+(?:\.\d+)?)(pt|px)?$/);
    if (match) {
        return parseFloat(match[1]);
    }
    
    return 12; // 默认值
}

/**
 * 转换对齐方式
 * @param {string} alignment - 对齐方式字符串
 * @returns {string} Word对齐方式常量
 */
function convertAlignment(alignment) {
    const alignmentMap = {
        '左对齐': Word.Alignment.left,
        '居中': Word.Alignment.centered,
        '右对齐': Word.Alignment.right,
        '两端对齐': Word.Alignment.justified
    };
    
    return alignmentMap[alignment] || Word.Alignment.left;
}

/**
 * 转换缩进值
 * @param {string} indent - 缩进字符串
 * @param {string} fontSize - 字体大小
 * @returns {number} 磅值
 */
function convertIndent(indent, fontSize) {
    if (indent.includes('字符')) {
        const chars = parseFloat(indent.replace('字符', ''));
        const fontSizePoints = convertFontSize(fontSize);
        // 1个中文字符约等于字体大小的磅值
        return chars * fontSizePoints;
    }
    
    const match = indent.match(/^(\d+(?:\.\d+)?)(pt|cm|mm)?$/);
    if (match) {
        const value = parseFloat(match[1]);
        const unit = match[2] || 'pt';
        
        switch (unit) {
            case 'cm': return value * 28.35;
            case 'mm': return value * 2.835;
            default: return value;
        }
    }
    
    return 0;
}

/**
 * 转换行距
 * @param {string} spacing - 行距字符串
 * @returns {number} 行距值
 */
function convertLineSpacing(spacing) {
    if (spacing.includes('倍')) {
        return parseFloat(spacing.replace('倍', ''));
    }
    
    const match = spacing.match(/^(\d+(?:\.\d+)?)(pt)?$/);
    if (match) {
        return parseFloat(match[1]);
    }
    
    return 1.15; // 默认值
}

/**
 * 转换间距值
 * @param {string} spacing - 间距字符串
 * @param {string} fontSize - 字体大小
 * @returns {number} 磅值
 */
function convertSpacing(spacing, fontSize) {
    if (spacing.includes('行')) {
        const lines = parseFloat(spacing.replace('行', ''));
        const fontSizePoints = convertFontSize(fontSize);
        return lines * fontSizePoints;
    }
    
    const match = spacing.match(/^(\d+(?:\.\d+)?)(pt|cm|mm)?$/);
    if (match) {
        const value = parseFloat(match[1]);
        const unit = match[2] || 'pt';
        
        switch (unit) {
            case 'cm': return value * 28.35;
            case 'mm': return value * 2.835;
            default: return value;
        }
    }
    
    return 0;
}

/**
 * 显示状态消息
 * @param {string} message - 消息内容
 * @param {string} type - 消息类型 (success, error, info, warning)
 */
function showStatus(message, type = 'info') {
    const statusElement = document.getElementById("statusMessage");
    statusElement.textContent = message;
    statusElement.className = `status-message ${type}`;
    
    // 成功消息3秒后自动消失
    if (type === 'success') {
        setTimeout(() => {
            statusElement.textContent = '';
            statusElement.className = 'status-message';
        }, 3000);
    }
}

/**
 * 设置加载状态
 * @param {boolean} loading - 是否加载中
 */
function setLoadingState(loading) {
    const button = document.getElementById("processButton");
    const container = document.getElementById("app-body");
    
    if (loading) {
        button.disabled = true;
        button.querySelector(".ms-Button-label").textContent = "处理中...";
        container.classList.add("loading");
    } else {
        button.disabled = false;
        button.querySelector(".ms-Button-label").textContent = "格式化并插入内容";
        container.classList.remove("loading");
    }
}
